#include "gdkmir.h"
#include "gdkmir-private.h"
-#include <mir_toolkit/events/surface_placement.h>
+#include <mir_toolkit/events/window_placement.h>
#define NANO_TO_MILLI(x) ((x) / 1000000)
}
static void
-handle_surface_event (GdkWindow *window, const MirSurfaceEvent *event)
+handle_window_event (GdkWindow *window,
+ const MirWindowEvent *event)
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirSurfaceState state;
+ MirWindowState state;
- switch (mir_surface_event_get_attribute (event))
+ switch (mir_window_event_get_attribute (event))
{
- case mir_surface_attrib_type:
- _gdk_mir_window_impl_set_surface_type (impl, mir_surface_event_get_attribute_value (event));
+ case mir_window_attrib_type:
+ _gdk_mir_window_impl_set_window_type (impl, mir_window_event_get_attribute_value (event));
break;
- case mir_surface_attrib_state:
- state = mir_surface_event_get_attribute_value (event);
- _gdk_mir_window_impl_set_surface_state (impl, state);
+ case mir_window_attrib_state:
+ state = mir_window_event_get_attribute_value (event);
+ _gdk_mir_window_impl_set_window_state (impl, state);
switch (state)
{
- case mir_surface_state_restored:
- case mir_surface_state_hidden:
+ case mir_window_state_restored:
+ case mir_window_state_hidden:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_MAXIMIZED |
GDK_WINDOW_STATE_FULLSCREEN,
0);
break;
- case mir_surface_state_minimized:
+ case mir_window_state_minimized:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_MAXIMIZED |
GDK_WINDOW_STATE_FULLSCREEN,
GDK_WINDOW_STATE_ICONIFIED);
break;
- case mir_surface_state_maximized:
- case mir_surface_state_vertmaximized:
- case mir_surface_state_horizmaximized:
+ case mir_window_state_maximized:
+ case mir_window_state_vertmaximized:
+ case mir_window_state_horizmaximized:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_FULLSCREEN,
GDK_WINDOW_STATE_MAXIMIZED);
break;
- case mir_surface_state_fullscreen:
+ case mir_window_state_fullscreen:
gdk_synthesize_window_state (window,
GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_MAXIMIZED,
}
break;
- case mir_surface_attrib_swapinterval:
+ case mir_window_attrib_swapinterval:
break;
- case mir_surface_attrib_focus:
- generate_focus_event (window, mir_surface_event_get_attribute_value (event) != 0);
+ case mir_window_attrib_focus:
+ generate_focus_event (window, mir_window_event_get_attribute_value (event) != 0);
break;
default:
break;
}
static void
-handle_surface_output_event (GdkWindow *window,
- const MirSurfaceOutputEvent *event)
+handle_window_output_event (GdkWindow *window,
+ const MirWindowOutputEvent *event)
{
- _gdk_mir_window_set_surface_output (window, mir_surface_output_event_get_scale (event));
+ _gdk_mir_window_set_scale (window, mir_window_output_event_get_scale (event));
}
static void
-handle_surface_placement_event (GdkWindow *window,
- const MirSurfacePlacementEvent *event)
+handle_window_placement_event (GdkWindow *window,
+ const MirWindowPlacementEvent *event)
{
- _gdk_mir_window_set_final_rect (window, mir_surface_placement_get_relative_position (event));
+ _gdk_mir_window_set_final_rect (window, mir_window_placement_get_relative_position (event));
}
typedef struct
case mir_event_type_motion:
handle_motion_event (window, mir_event_get_input_event (event));
break;
- case mir_event_type_surface:
- handle_surface_event (window, mir_event_get_surface_event (event));
+ case mir_event_type_window:
+ handle_window_event (window, mir_event_get_window_event (event));
break;
case mir_event_type_resize:
handle_resize_event (window, mir_event_get_resize_event (event));
case mir_event_type_orientation:
// FIXME?
break;
- case mir_event_type_close_surface:
+ case mir_event_type_close_window:
handle_close_event (window);
break;
- case mir_event_type_surface_output:
- handle_surface_output_event (window, mir_event_get_surface_output_event (event));
+ case mir_event_type_window_output:
+ handle_window_output_event (window, mir_event_get_window_output_event (event));
break;
- case mir_event_type_surface_placement:
- handle_surface_placement_event (window, mir_event_get_surface_placement_event (event));
+ case mir_event_type_window_placement:
+ handle_window_placement_event (window, mir_event_get_window_placement_event (event));
break;
default:
g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event));
GdkDisplay *display;
/* Current monitor configuration */
- MirDisplayConfiguration *display_config;
+ MirDisplayConfig *display_config;
GdkWindow *root_window;
};
}
static void
-get_screen_size (MirDisplayConfiguration *config, gint *width, gint *height)
+get_screen_size (MirDisplayConfig *config,
+ gint *width,
+ gint *height)
{
- uint32_t i;
+ const MirOutput *output;
+ const MirOutputMode *mode;
+ gint right;
+ gint bottom;
+ gint i;
*width = 0;
*height = 0;
if (!config)
return;
- for (i = 0; i < config->num_outputs; i++)
+ for (i = 0; i < mir_display_config_get_num_outputs (config); i++)
{
- MirDisplayOutput *o = &config->outputs[i];
- gint w, h;
+ output = mir_display_config_get_output (config, i);
- if (!o->used)
+ if (!mir_output_is_enabled (output))
continue;
- w = o->position_x + o->modes[o->current_mode].horizontal_resolution;
- if (w > *width)
- *width = w;
- h = o->position_y + o->modes[o->current_mode].vertical_resolution;
- if (h > *height)
- *height = h;
+ mode = mir_output_get_current_mode (output);
+
+ right = mir_output_get_position_x (output) + mir_output_mode_get_width (mode);
+ bottom = mir_output_get_position_y (output) + mir_output_mode_get_height (mode);
+
+ if (right > *width)
+ *width = right;
+
+ if (bottom > *height)
+ *height = bottom;
}
}
update_display_config (GdkMirScreen *screen)
{
gdk_mir_display_get_mir_connection (GDK_DISPLAY (screen->display));
- mir_display_config_destroy (screen->display_config);
- screen->display_config = mir_connection_create_display_config (get_connection (screen));
+ mir_display_config_release (screen->display_config);
+ screen->display_config = mir_connection_create_display_configuration (get_connection (screen));
}
static void
GdkMirScreen *screen = GDK_MIR_SCREEN (object);
mir_connection_set_display_config_change_callback (get_connection (screen), NULL, NULL);
- mir_display_config_destroy (screen->display_config);
+ mir_display_config_release (screen->display_config);
g_clear_object (&screen->root_window);
G_OBJECT_CLASS (gdk_mir_screen_parent_class)->finalize (object);
return GDK_DISPLAY (GDK_MIR_SCREEN (screen)->display);
}
-static MirDisplayOutput *
-get_output (GdkScreen *screen, gint monitor_num)
+static const MirOutput *
+get_output (GdkScreen *screen,
+ gint monitor_num)
{
- MirDisplayConfiguration *config;
- uint32_t i, j;
+ MirDisplayConfig *config;
+ const MirOutput *output;
+ gint i;
+ gint j;
config = GDK_MIR_SCREEN (screen)->display_config;
- for (i = 0, j = 0; i < config->num_outputs; i++)
+ for (i = 0, j = 0; i < mir_display_config_get_num_outputs (config); i++)
{
- if (!config->outputs[i].used)
+ output = mir_display_config_get_output (config, i);
+
+ if (!mir_output_is_enabled (output))
continue;
if (j == monitor_num)
- return &config->outputs[i];
+ return output;
+
j++;
}
gdk_mir_screen_get_n_monitors (GdkScreen *screen)
{
//g_printerr ("gdk_mir_screen_get_n_monitors\n");
- MirDisplayConfiguration *config;
- uint32_t i;
+ MirDisplayConfig *config;
gint count = 0;
+ gint i;
config = GDK_MIR_SCREEN (screen)->display_config;
- for (i = 0; i < config->num_outputs; i++)
- if (config->outputs[i].used)
- ++count;
+ for (i = 0; i < mir_display_config_get_num_outputs (config); i++)
+ if (mir_output_is_enabled (mir_display_config_get_output (config, i)))
+ count++;
return count;
}
gint monitor_num)
{
//g_printerr ("gdk_mir_screen_get_monitor_width_mm (%d)\n", monitor_num);
- MirDisplayOutput *output = get_output (screen, monitor_num);
- return output ? output->physical_width_mm : 0;
+ const MirOutput *output = get_output (screen, monitor_num);
+
+ return output ? mir_output_get_physical_width_mm (output) : 0;
}
static gint
gint monitor_num)
{
//g_printerr ("gdk_mir_screen_get_monitor_height_mm (%d)\n", monitor_num);
- MirDisplayOutput *output = get_output (screen, monitor_num);
- return output ? output->physical_height_mm : 0;
+ const MirOutput *output = get_output (screen, monitor_num);
+
+ return output ? mir_output_get_physical_height_mm (output) : 0;
}
static gchar *
gint monitor_num)
{
//g_printerr ("gdk_mir_screen_get_monitor_plug_name (%d)\n", monitor_num);
- MirDisplayOutput *output = get_output (screen, monitor_num);
+ const MirOutput *output = get_output (screen, monitor_num);
if (output)
{
- switch (output->type)
+ switch (mir_output_get_type (output))
{
- case mir_display_output_type_unknown:
- return g_strdup_printf ("None-%u", output->output_id);
- case mir_display_output_type_vga:
- return g_strdup_printf ("VGA-%u", output->output_id);
- case mir_display_output_type_dvii:
- case mir_display_output_type_dvid:
- case mir_display_output_type_dvia:
- return g_strdup_printf ("DVI-%u", output->output_id);
- case mir_display_output_type_composite:
- return g_strdup_printf ("Composite-%u", output->output_id);
- case mir_display_output_type_lvds:
- return g_strdup_printf ("LVDS-%u", output->output_id);
- case mir_display_output_type_component:
- return g_strdup_printf ("CTV-%u", output->output_id);
- case mir_display_output_type_ninepindin:
- return g_strdup_printf ("DIN-%u", output->output_id);
- case mir_display_output_type_displayport:
- return g_strdup_printf ("DP-%u", output->output_id);
- case mir_display_output_type_hdmia:
- case mir_display_output_type_hdmib:
- return g_strdup_printf ("HDMI-%u", output->output_id);
- case mir_display_output_type_svideo:
- case mir_display_output_type_tv:
- return g_strdup_printf ("TV-%u", output->output_id);
- case mir_display_output_type_edp:
- return g_strdup_printf ("eDP-%u", output->output_id);
- case mir_display_output_type_virtual:
- return g_strdup_printf ("Virtual-%u", output->output_id);
- case mir_display_output_type_dsi:
- return g_strdup_printf ("DSI-%u", output->output_id);
- case mir_display_output_type_dpi:
- return g_strdup_printf ("DPI-%u", output->output_id);
+ case mir_output_type_unknown:
+ return g_strdup_printf ("None-%u", mir_output_get_id (output));
+ case mir_output_type_vga:
+ return g_strdup_printf ("VGA-%u", mir_output_get_id (output));
+ case mir_output_type_dvii:
+ case mir_output_type_dvid:
+ case mir_output_type_dvia:
+ return g_strdup_printf ("DVI-%u", mir_output_get_id (output));
+ case mir_output_type_composite:
+ return g_strdup_printf ("Composite-%u", mir_output_get_id (output));
+ case mir_output_type_lvds:
+ return g_strdup_printf ("LVDS-%u", mir_output_get_id (output));
+ case mir_output_type_component:
+ return g_strdup_printf ("CTV-%u", mir_output_get_id (output));
+ case mir_output_type_ninepindin:
+ return g_strdup_printf ("DIN-%u", mir_output_get_id (output));
+ case mir_output_type_displayport:
+ return g_strdup_printf ("DP-%u", mir_output_get_id (output));
+ case mir_output_type_hdmia:
+ case mir_output_type_hdmib:
+ return g_strdup_printf ("HDMI-%u", mir_output_get_id (output));
+ case mir_output_type_svideo:
+ case mir_output_type_tv:
+ return g_strdup_printf ("TV-%u", mir_output_get_id (output));
+ case mir_output_type_edp:
+ return g_strdup_printf ("eDP-%u", mir_output_get_id (output));
+ case mir_output_type_virtual:
+ return g_strdup_printf ("Virtual-%u", mir_output_get_id (output));
+ case mir_output_type_dsi:
+ return g_strdup_printf ("DSI-%u", mir_output_get_id (output));
+ case mir_output_type_dpi:
+ return g_strdup_printf ("DPI-%u", mir_output_get_id (output));
}
}
GdkRectangle *dest)
{
//g_printerr ("gdk_mir_screen_get_monitor_geometry (%d)\n", monitor_num);
- MirDisplayOutput *output;
- MirDisplayMode *mode;
+ const MirOutput *output;
+ const MirOutputMode *mode;
output = get_output (screen, monitor_num);
if (output)
{
- mode = &output->modes[output->current_mode];
- dest->x = output->position_x;
- dest->y = output->position_y;
- dest->width = mode->horizontal_resolution;
- dest->height = mode->vertical_resolution;
+ mode = mir_output_get_current_mode (output);
+
+ dest->x = mir_output_get_position_x (output);
+ dest->y = mir_output_get_position_y (output);
+ dest->width = mir_output_mode_get_width (mode);
+ dest->height = mir_output_mode_get_height (mode);
}
else
{
gint rect_anchor_dx;
gint rect_anchor_dy;
- /* Desired surface attributes */
+ /* Desired window attributes */
GdkWindowTypeHint type_hint;
- MirSurfaceState surface_state;
+ MirWindowState window_state;
gboolean modal;
/* Current button state for checking which buttons are being pressed / released */
GdkDisplay *display;
- /* Surface being rendered to (only exists when window visible) */
- MirSurface *surface;
+ /* Window being rendered to (only exists when visible) */
+ MirWindow *mir_window;
MirBufferStream *buffer_stream;
MirBufferUsage buffer_usage;
GdkGeometry geometry_hints;
GdkWindowHints geometry_mask;
- /* Egl surface for the current mir surface */
+ /* Egl surface for the current mir window */
EGLSurface egl_surface;
/* Dummy MIR and EGL surfaces */
G_DEFINE_TYPE (GdkMirWindowImpl, gdk_mir_window_impl, GDK_TYPE_WINDOW_IMPL)
static cairo_surface_t *gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window);
-static void ensure_surface (GdkWindow *window);
-static void apply_geometry_hints (MirSurfaceSpec *spec, GdkMirWindowImpl *impl);
+static void ensure_mir_window (GdkWindow *window);
static gboolean
type_hint_differs (GdkWindowTypeHint lhs, GdkWindowTypeHint rhs)
}
void
-_gdk_mir_window_impl_set_surface_state (GdkMirWindowImpl *impl, MirSurfaceState state)
+_gdk_mir_window_impl_set_window_state (GdkMirWindowImpl *impl,
+ MirWindowState state)
{
- impl->surface_state = state;
+ impl->window_state = state;
}
void
-_gdk_mir_window_impl_set_surface_type (GdkMirWindowImpl *impl,
- MirSurfaceType type)
+_gdk_mir_window_impl_set_window_type (GdkMirWindowImpl *impl,
+ MirWindowType type)
{
}
{
impl->properties = g_hash_table_new_full (NULL, NULL, NULL, gdk_mir_property_free);
impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
- impl->surface_state = mir_surface_state_unknown;
+ impl->window_state = mir_window_state_unknown;
impl->output_scale = 1;
}
static void
-set_surface_state (GdkMirWindowImpl *impl,
- MirSurfaceState state)
+set_window_state (GdkMirWindowImpl *impl,
+ MirWindowState state)
{
MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
- if (impl->surface_state == state)
+ MirWindowSpec *spec;
+
+ if (state == impl->window_state)
return;
- impl->surface_state = state;
- if (impl->surface && !impl->pending_spec_update)
+ impl->window_state = state;
+
+ if (impl->mir_window && !impl->pending_spec_update)
{
- MirSurfaceSpec *spec = mir_connection_create_spec_for_changes (connection);
- mir_surface_spec_set_state (spec, state);
- mir_surface_apply_spec (impl->surface, spec);
- mir_surface_spec_release (spec);
+ spec = mir_create_window_spec (connection);
+ mir_window_spec_set_state (spec, state);
+ mir_window_apply_spec (impl->mir_window, spec);
+ mir_window_spec_release (spec);
}
}
static void
-event_cb (MirSurface *surface,
+event_cb (MirWindow *mir_window,
const MirEvent *event,
void *context)
{
_gdk_mir_event_source_queue (context, event);
}
-static MirSurfaceSpec *
+static MirWindowSpec *
create_window_type_spec (GdkDisplay *display,
GdkWindow *parent,
gint x,
MirBufferUsage buffer_usage)
{
MirConnection *connection = gdk_mir_display_get_mir_connection (display);
- MirSurface *parent_surface = NULL;
+ MirWindow *parent_mir_window = NULL;
MirPixelFormat format;
MirRectangle rect;
+ MirWindowSpec *spec;
if (parent && parent->impl)
{
- ensure_surface (parent);
- parent_surface = GDK_MIR_WINDOW_IMPL (parent->impl)->surface;
+ ensure_mir_window (parent);
+ parent_mir_window = GDK_MIR_WINDOW_IMPL (parent->impl)->mir_window;
}
- if (!parent_surface)
+ if (!parent_mir_window)
{
switch (type)
{
{
case GDK_WINDOW_TYPE_HINT_DIALOG:
if (modal)
- return mir_connection_create_spec_for_modal_dialog (connection,
- width,
- height,
- format,
- parent_surface);
- else
- return mir_connection_create_spec_for_dialog (connection,
- width,
- height,
- format);
- case GDK_WINDOW_TYPE_HINT_DOCK:
- return mir_connection_create_spec_for_dialog (connection,
+ spec = mir_create_modal_dialog_window_spec (connection,
width,
height,
- format);
+ parent_mir_window);
+ else
+ spec = mir_create_dialog_window_spec (connection,
+ width,
+ height);
+ break;
+ case GDK_WINDOW_TYPE_HINT_DOCK:
+ spec = mir_create_dialog_window_spec (connection,
+ width,
+ height);
+ break;
case GDK_WINDOW_TYPE_HINT_MENU:
case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
case GDK_WINDOW_TYPE_HINT_DND:
case GDK_WINDOW_TYPE_HINT_TOOLTIP:
case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
- return mir_connection_create_spec_for_menu (connection,
- width,
- height,
- format,
- parent_surface,
- &rect,
- 0);
+ spec = mir_create_menu_window_spec (connection,
+ width,
+ height,
+ parent_mir_window,
+ &rect,
+ 0);
+ break;
case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
case GDK_WINDOW_TYPE_HINT_UTILITY:
- return mir_connection_create_spec_for_modal_dialog (connection,
- width,
- height,
- format,
- parent_surface);
+ spec = mir_create_modal_dialog_window_spec (connection,
+ width,
+ height,
+ parent_mir_window);
+ break;
case GDK_WINDOW_TYPE_HINT_NORMAL:
case GDK_WINDOW_TYPE_HINT_DESKTOP:
default:
- return mir_connection_create_spec_for_normal_surface (connection,
- width,
- height,
- format);
+ spec = mir_create_normal_window_spec (connection,
+ width,
+ height);
+ break;
}
+
+ mir_window_spec_set_pixel_format (spec, format);
+
+ return spec;
}
static void
-apply_geometry_hints (MirSurfaceSpec *spec, GdkMirWindowImpl *impl)
+apply_geometry_hints (MirWindowSpec *spec,
+ GdkMirWindowImpl *impl)
{
if (impl->geometry_mask & GDK_HINT_RESIZE_INC)
{
- mir_surface_spec_set_width_increment (spec, impl->geometry_hints.width_inc);
- mir_surface_spec_set_height_increment (spec, impl->geometry_hints.height_inc);
+ mir_window_spec_set_width_increment (spec, impl->geometry_hints.width_inc);
+ mir_window_spec_set_height_increment (spec, impl->geometry_hints.height_inc);
}
if (impl->geometry_mask & GDK_HINT_MIN_SIZE)
{
- mir_surface_spec_set_min_width (spec, impl->geometry_hints.min_width);
- mir_surface_spec_set_min_height (spec, impl->geometry_hints.min_height);
+ mir_window_spec_set_min_width (spec, impl->geometry_hints.min_width);
+ mir_window_spec_set_min_height (spec, impl->geometry_hints.min_height);
}
if (impl->geometry_mask & GDK_HINT_MAX_SIZE)
{
- mir_surface_spec_set_max_width (spec, impl->geometry_hints.max_width);
- mir_surface_spec_set_max_height (spec, impl->geometry_hints.max_height);
+ mir_window_spec_set_max_width (spec, impl->geometry_hints.max_width);
+ mir_window_spec_set_max_height (spec, impl->geometry_hints.max_height);
}
if (impl->geometry_mask & GDK_HINT_ASPECT)
{
- mir_surface_spec_set_min_aspect_ratio (spec, 1000, (unsigned)(1000.0/impl->geometry_hints.min_aspect));
- mir_surface_spec_set_max_aspect_ratio (spec, 1000, (unsigned)(1000.0/impl->geometry_hints.max_aspect));
+ mir_window_spec_set_min_aspect_ratio (spec, (guint) 1000 * impl->geometry_hints.min_aspect, 1000);
+ mir_window_spec_set_max_aspect_ratio (spec, (guint) 1000 * impl->geometry_hints.max_aspect, 1000);
}
}
-static MirSurfaceSpec*
-create_spec (GdkWindow *window, GdkMirWindowImpl *impl)
+static MirWindowSpec *
+create_spec (GdkWindow *window,
+ GdkMirWindowImpl *impl)
{
- MirSurfaceSpec *spec = NULL;
+ MirWindowSpec *spec = NULL;
GdkWindow *parent;
spec = create_window_type_spec (impl->display,
impl->type_hint,
impl->buffer_usage);
- mir_surface_spec_set_name (spec, impl->title);
- mir_surface_spec_set_buffer_usage (spec, impl->buffer_usage);
+ mir_window_spec_set_name (spec, impl->title);
+ mir_window_spec_set_buffer_usage (spec, impl->buffer_usage);
apply_geometry_hints (spec, impl);
parent = gdk_window_get_parent (parent);
}
- mir_surface_spec_set_placement (spec,
- &impl->mir_rect,
- impl->rect_anchor,
- impl->window_anchor,
- impl->anchor_hints,
- impl->rect_anchor_dx,
- impl->rect_anchor_dy);
+ mir_window_spec_set_placement (spec,
+ &impl->mir_rect,
+ impl->rect_anchor,
+ impl->window_anchor,
+ impl->anchor_hints,
+ impl->rect_anchor_dx,
+ impl->rect_anchor_dy);
}
return spec;
}
static void
-update_surface_spec (GdkWindow *window)
+update_window_spec (GdkWindow *window)
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- MirSurfaceSpec *spec;
+ MirWindowSpec *spec;
- if (!impl->surface)
+ if (!impl->mir_window)
return;
spec = create_spec (window, impl);
- mir_surface_apply_spec (impl->surface, spec);
- mir_surface_spec_release (spec);
+ mir_window_apply_spec (impl->mir_window, spec);
+ mir_window_spec_release (spec);
+
impl->pending_spec_update = FALSE;
- impl->buffer_stream = mir_surface_get_buffer_stream (impl->surface);
+ impl->buffer_stream = mir_window_get_buffer_stream (impl->mir_window);
}
static GdkDevice *
}
static void
-ensure_surface_full (GdkWindow *window,
- MirBufferUsage buffer_usage)
+ensure_mir_window_full (GdkWindow *window,
+ MirBufferUsage buffer_usage)
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
GdkMirWindowReference *window_ref;
- MirSurfaceSpec *spec;
+ MirWindowSpec *spec;
- if (impl->surface)
+ if (impl->mir_window)
{
if (impl->pending_spec_update)
- update_surface_spec(window);
+ update_window_spec (window);
return;
}
spec = create_spec (window, impl);
- impl->surface = mir_surface_create_sync (spec);
+ impl->mir_window = mir_create_window_sync (spec);
- mir_surface_spec_release(spec);
+ mir_window_spec_release (spec);
impl->pending_spec_update = FALSE;
- impl->buffer_stream = mir_surface_get_buffer_stream (impl->surface);
+ impl->buffer_stream = mir_window_get_buffer_stream (impl->mir_window);
/* FIXME: can't make an initial resize event */
// MirEvent *resize_event;
generate_configure_event (window, window->width, window->height);
- mir_surface_set_event_handler (impl->surface, event_cb, window_ref); // FIXME: Ignore some events until shown
+ /* FIXME: Ignore some events until shown */
+ mir_window_set_event_handler (impl->mir_window, event_cb, window_ref);
}
static void
-ensure_surface (GdkWindow *window)
+ensure_mir_window (GdkWindow *window)
{
- ensure_surface_full (window,
- window->gl_paint_context ?
- mir_buffer_usage_hardware :
- mir_buffer_usage_software);
+ ensure_mir_window_full (window,
+ window->gl_paint_context ?
+ mir_buffer_usage_hardware :
+ mir_buffer_usage_software);
}
static void
-ensure_no_surface (GdkWindow *window)
+ensure_no_mir_window (GdkWindow *window)
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
}
}
- g_clear_pointer(&impl->surface, mir_surface_release_sync);
+ g_clear_pointer (&impl->mir_window, mir_window_release_sync);
}
static void
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
/* Send the completed buffer to Mir */
- mir_buffer_stream_swap_buffers_sync (mir_surface_get_buffer_stream (impl->surface));
+ mir_buffer_stream_swap_buffers_sync (mir_window_get_buffer_stream (impl->mir_window));
/* The Cairo context is no longer valid */
g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
if (impl->pending_spec_update)
- update_surface_spec (window);
+ update_window_spec (window);
impl->pending_spec_update = FALSE;
}
return impl->cairo_surface;
}
- ensure_surface (window);
+ ensure_mir_window (window);
if (window->gl_paint_context)
{
}
else if (impl->visible)
{
- mir_buffer_stream_get_graphics_region (mir_surface_get_buffer_stream (impl->surface), ®ion);
+ mir_buffer_stream_get_graphics_region (mir_window_get_buffer_stream (impl->mir_window), ®ion);
switch (region.pixel_format)
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (object);
g_free (impl->title);
- if (impl->surface)
- mir_surface_release_sync (impl->surface);
- if (impl->cairo_surface)
- cairo_surface_destroy (impl->cairo_surface);
+ g_clear_pointer (&impl->mir_window, mir_window_release_sync);
+ g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy);
g_clear_pointer (&impl->properties, g_hash_table_unref);
G_OBJECT_CLASS (gdk_mir_window_impl_parent_class)->finalize (object);
//g_printerr ("gdk_mir_window_impl_show window=%p\n", window);
impl->visible = TRUE;
- set_surface_state (impl, mir_surface_state_restored);
+ set_window_state (impl, mir_window_state_restored);
- /* Make sure there's a surface to see */
- ensure_surface (window);
+ /* Make sure there's a window to see */
+ ensure_mir_window (window);
if (!window->gl_paint_context)
{
impl->cursor_inside = FALSE;
impl->visible = FALSE;
- set_surface_state (impl, mir_surface_state_hidden);
+ set_window_state (impl, mir_window_state_hidden);
}
static void
impl->cursor_inside = FALSE;
impl->visible = FALSE;
- set_surface_state (impl, mir_surface_state_hidden);
+ set_window_state (impl, mir_window_state_hidden);
}
static void
*/
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
- /* If resize requested then rebuild surface */
+ /* If resize requested then rebuild window */
if (width >= 0 && (window->width != width || window->height != height))
{
/* We accept any resize */
impl->has_rect = FALSE;
impl->transient_x = x;
impl->transient_y = y;
- if (!impl->pending_spec_update && impl->surface)
- update_surface_spec (window);
+ if (!impl->pending_spec_update && impl->mir_window)
+ update_window_spec (window);
}
}
}
impl->rect_anchor_dx = rect_anchor_dx + get_window_shadow_dx (window, window_anchor);
impl->rect_anchor_dy = rect_anchor_dy + get_window_shadow_dy (window, window_anchor);
- if (impl->surface && !impl->pending_spec_update)
- update_surface_spec (window);
+ if (impl->mir_window && !impl->pending_spec_update)
+ update_window_spec (window);
}
static gint
GdkDevice *device,
GdkCursor *cursor)
{
+ GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
+ MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
+ MirWindowSpec *spec;
const gchar *cursor_name;
- MirCursorConfiguration *configuration;
if (cursor)
cursor_name = _gdk_mir_cursor_get_name (cursor);
else
cursor_name = mir_default_cursor_name;
- configuration = mir_cursor_configuration_from_name (cursor_name);
-
- if (configuration)
- {
- GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- if (impl->surface)
- mir_surface_configure_cursor (impl->surface, configuration);
-
- mir_cursor_configuration_destroy (configuration);
- }
+ spec = mir_create_window_spec (connection);
+ mir_window_spec_set_cursor_name (spec, cursor_name);
+ mir_window_apply_spec (impl->mir_window, spec);
+ mir_window_spec_release (spec);
}
static void
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
impl->visible = FALSE;
- ensure_no_surface (window);
+ ensure_no_mir_window (window);
}
static void
if (type_hint_differs (hint, impl->type_hint))
{
impl->type_hint = hint;
- if (impl->surface && !impl->pending_spec_update)
- update_surface_spec (window);
+
+ if (impl->mir_window && !impl->pending_spec_update)
+ update_window_spec (window);
}
}
{
impl->modal = modal;
- if (impl->surface && !impl->pending_spec_update)
- update_surface_spec (window);
+ if (impl->mir_window && !impl->pending_spec_update)
+ update_window_spec (window);
}
}
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
+ MirWindowSpec *spec;
//g_printerr ("gdk_mir_window_impl_set_geometry_hints window=%p impl=%p\n", window, impl);
impl->geometry_hints = *geometry;
impl->geometry_mask = geom_mask;
- if (impl->surface && !impl->pending_spec_update)
+ if (impl->mir_window && !impl->pending_spec_update)
{
- MirSurfaceSpec* spec = mir_connection_create_spec_for_changes (connection);
+ spec = mir_create_window_spec (connection);
apply_geometry_hints (spec, impl);
- mir_surface_apply_spec (impl->surface, spec);
- mir_surface_spec_release (spec);
+ mir_window_apply_spec (impl->mir_window, spec);
+ mir_window_spec_release (spec);
}
}
{
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
MirConnection *connection = gdk_mir_display_get_mir_connection (impl->display);
+ MirWindowSpec *spec;
//g_printerr ("gdk_mir_window_impl_set_title window=%p\n", window);
g_free (impl->title);
impl->title = g_strdup (title);
- if (impl->surface && !impl->pending_spec_update)
+
+ if (impl->mir_window && !impl->pending_spec_update)
{
- MirSurfaceSpec* spec = mir_connection_create_spec_for_changes (connection);
- mir_surface_spec_set_name (spec, impl->title);
- mir_surface_apply_spec (impl->surface, spec);
- mir_surface_spec_release (spec);
+ spec = mir_create_window_spec (connection);
+ mir_window_spec_set_name (spec, impl->title);
+ mir_window_apply_spec (impl->mir_window, spec);
+ mir_window_spec_release (spec);
}
}
/* Link this window to the parent */
impl->transient_for = parent;
- if (impl->surface && !impl->pending_spec_update)
- update_surface_spec (window);
+ if (impl->mir_window && !impl->pending_spec_update)
+ update_window_spec (window);
}
static void
gdk_mir_window_impl_maximize (GdkWindow *window)
{
//g_printerr ("gdk_mir_window_impl_maximize window=%p\n", window);
- set_surface_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_surface_state_maximized);
+ set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_maximized);
}
static void
gdk_mir_window_impl_unmaximize (GdkWindow *window)
{
//g_printerr ("gdk_mir_window_impl_unmaximize window=%p\n", window);
- set_surface_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_surface_state_restored);
+ set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_restored);
}
static void
gdk_mir_window_impl_fullscreen (GdkWindow *window)
{
//g_printerr ("gdk_mir_window_impl_fullscreen window=%p\n", window);
- set_surface_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_surface_state_fullscreen);
+ set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_fullscreen);
}
static void
gdk_mir_window_impl_unfullscreen (GdkWindow *window)
{
//g_printerr ("gdk_mir_window_impl_unfullscreen window=%p\n", window);
- set_surface_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_surface_state_restored);
+ set_window_state (GDK_MIR_WINDOW_IMPL (window->impl), mir_window_state_restored);
}
static void
EGLDisplay egl_display;
EGLNativeWindowType egl_window;
- ensure_no_surface (window);
- ensure_surface_full (window, mir_buffer_usage_hardware);
+ ensure_no_mir_window (window);
+ ensure_mir_window_full (window, mir_buffer_usage_hardware);
egl_display = _gdk_mir_display_get_egl_display (gdk_window_get_display (window));
egl_window = (EGLNativeWindowType) mir_buffer_stream_get_egl_native_window (impl->buffer_stream);
MirSurface *
gdk_mir_window_get_mir_surface (GdkWindow *window)
{
- GdkMirWindowImpl *impl;
+ return _gdk_mir_window_get_mir_window (window);
+}
+MirWindow *
+_gdk_mir_window_get_mir_window (GdkWindow *window)
+{
g_return_val_if_fail (GDK_IS_MIR_WINDOW (window), NULL);
- impl = GDK_MIR_WINDOW_IMPL (window->impl);
-
- return impl->surface;
+ return GDK_MIR_WINDOW_IMPL (window->impl)->mir_window;
}
void
-_gdk_mir_window_set_surface_output (GdkWindow *window, gdouble scale)
+_gdk_mir_window_set_scale (GdkWindow *window,
+ gdouble scale)
{
- // g_printerr ("_gdk_mir_window_impl_set_surface_output impl=%p\n", impl);
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
GdkRectangle area = {0, 0, window->width, window->height};
cairo_region_t *region;
gint new_scale = (gint) round (scale);
+ // g_printerr ("_gdk_mir_window_set_scale impl=%p\n", impl);
if (impl->output_scale != new_scale)
{
projects / gtk4.git / commitdiff